// exports.ExcelUtil = void 0;
// var $baseExcel = require("./BaseExcel");
// var i = (function () {
//     function e() {}
//     e.valueToString = function (t, o) {
//         switch (t) {
//             case "string":
//                 return o;
//             case "string[]":
//                 return o.join(",");
//             case "number":
//                 return o + "";
//             case "number[]":
//                 return o.join(",");
//             case "number[][]":
//                 for (var n = [], i = 0; i < o.length; i++) {
//                     n.push(o[i].join(","));
//                 }
//                 return n.join(";");
//             case "cc.Vec2":
//                 return o.x + "," + o.y;
//             case "cc.Vec2[]":
//                 var a = [];
//                 for (i = 0; i < o.length; i++) {
//                     a.push(o[i].x + "," + o[i].y);
//                 }
//                 return a.join(";");
//             case "cc.Color":
//                 return o.toHEX("#rrggbb");
//             case "cc.Color[]":
//                 var r = [];
//                 for (i = 0; i < o.length; i++) {
//                     r.push(o[i].toHEX("#rrggbb"));
//                 }
//                 return r.join(",");
//             case "itemData":
//                 return e.itemToStr([o]);
//             case "itemData[]":
//                 var c = [];
//                 for (i = 0; i < o.length; i++) {
//                     c.push(e.itemToStr([o[i]]));
//                 }
//                 return c.join(";");
//             case "boolean":
//                 return (o ? 1 : 0) + "";
//             case "boolean[]":
//                 var s = [];
//                 for (i = 0; i < o.length; i++) {
//                     s.push(o[i] ? 1 : 0);
//                 }
//                 return s.join(",");
//             default:
//                 return o;
//         }
//     };
//     e.dataTypeConvert = function (t, o) {
//         switch (o) {
//             case "string":
//                 return t;
//             case "string[]":
//                 return t.split(",");
//             case "number":
//                 if ("" == t) {
//                     return 0;
//                 } else {
//                     return Number(t);
//                 }
//             case "number[]":
//                 return e.stringToNumberArr(t);
//             case "number[][]":
//                 return e.stringToNumberArrArr(t);
//             case "cc.Vec2":
//                 return e.stringToVec(t);
//             case "cc.Vec2[]":
//                 return e.stringToVecArr(t);
//             case "cc.Color":
//                 return e.stringToColor(t);
//             case "cc.Color[]":
//                 return e.stringToColorArr(t);
//             case "itemData":
//                 return e.stringToItem(t);
//             case "itemData[]":
//                 return e.stringToItemArr(t);
//             case "boolean":
//                 return e.stringToBoolean(t);
//             case "boolean[]":
//                 return e.stringTpBooleanArr(t);
//             default:
//                 return t;
//         }
//     };
//     e.itemToStr = function (e) {
//         var t = "";
//         for (var o = 0; o < e.length; o++) {
//             if (0 == o) {
//                 t = e[o].key + "," + e[o].value;
//             } else {
//                 t = t + ";" + e[o].key + "," + e[o].value;
//             }
//         }
//         return t;
//     };
//     e.stringToBoolean = function (e) {
//         return !("" == e || "0" == e || "false" == e.toLowerCase());
//     };
//     e.stringTpBooleanArr = function (t) {
//         var o = [];
//         if (t.length > 0) {
//             var n = t.split(",");
//             for (var i = 0; i < n.length; i++) {
//                 o.push(e.stringToBoolean(n[i]));
//             }
//         }
//         return o;
//     };
//     e.stringToColorArr = function (t) {
//         var o = [];
//         if (t.length > 0) {
//             var n = t.split(",");
//             for (var i = 0; i < n.length; i++) {
//                 o.push(e.stringToColor(n[i]));
//             }
//         }
//         return o;
//     };
//     e.stringToColor = function (e) {
//         if (e.length >= 6) {
//             var t = "0x" + e.substring(0, 2);
//             var o = "0x" + e.substring(2, 4);
//             var n = "0x" + e.substring(4, 6);
//             var i = "";
//             if (e.length > 6) {
//                 i = "0x" + e.substring(6, 8);
//             }
//             var a = parseInt(t);
//             var r = parseInt(o);
//             var c = parseInt(n);
//             var s;
//             if ("" == i) {
//                 s = 255;
//             } else {
//                 s = parseInt(i);
//             }
//             return new cc.Color(a, r, c, s);
//         }
//         return cc.Color.BLACK;
//     };
//     e.stringToVecArr = function (t) {
//         var o = [];
//         if (t.length > 0) {
//             var n = t.split(";");
//             for (var i = 0; i < n.length; i++) {
//                 o.push(e.stringToVec(n[i]));
//             }
//         }
//         return o;
//     };
//     e.stringToVec = function (t) {
//         var o = e.stringToNumberArr(t);
//         if (o.length >= 2) {
//             return cc.v2(o[0], o[1]);
//         } else {
//             return cc.v2(0, 0);
//         }
//     };
//     e.stringToNumberArr = function (e) {
//         var t = [];
//         if (e.length > 0) {
//             var o = e.split(",");
//             for (var n = 0; n < o.length; n++) {
//                 t.push(Number(o[n]));
//             }
//         }
//         return t;
//     };
//     e.stringToNumberArrArr = function (t) {
//         var o = [];
//         if (t.length > 0) {
//             var n = t.split(";");
//             for (var i = 0; i < n.length; i++) {
//                 o.push(e.stringToNumberArr(n[i]));
//             }
//         }
//         return o;
//     };
//     e.itemToString = function (e) {
//         if (e.extent) {
//             return e.key + "," + e.extent + "," + e.value;
//         } else {
//             return e.key + "," + e.value;
//         }
//     };
//     e.stringToItem = function (t) {
//         var o = e.stringToNumberArr(t);
//         var i = o.length;
//         if (2 == i) {
//             return new $baseExcel.itemData(o[0], o[1]);
//         } else {
//             return i > 2 ? new $baseExcel.itemData(o[0], o[1], o[2]) : null;
//         }
//     };
//     e.stringToItemArr = function (t) {
//         var o = [];
//         if (t.length > 0) {
//             var n = t.split(";");
//             for (var i = 0; i < n.length; i++) {
//                 o.push(e.stringToItem(n[i]));
//             }
//         }
//         return o;
//     };
//     e.itemArrToString = function (e) {
//         var t = [];
//         for (var o = 0; o < e.length; o++) {
//             t.push(this.itemToString(e[o]));
//         }
//         return t.join(";");
//     };
//     e.jsonToValue = function (t, o, n, i) {
//         var a = {
//             talk_task: "talk"
//         }[n];
//         for (var r in o) {
//             var c = t[r] || "";
//             if (a && o[r] == a && c.indexOf("\\n") >= 0) {
//                 c.replace(/\\n/g, "\n");
//             }
//             i[o[r]] = e.dataTypeConvert(c, i.typeStr[o[r]]);
//         }
//     };
//     e.convert = function (t, o, n) {
//         if (o instanceof cc.JsonAsset) {
//             var i = o.json.rows;
//             var a = o.json.header;
//             var r = new Map();
//             for (var c in i) {
//                 var s = new n();
//                 e.jsonToValue(i[c], a, t, s);
//                 if ((h = parseInt(c))) {
//                     r.set(h, s);
//                 }
//             }
//             return r;
//         }
//         if (o instanceof Array) {
//             r = new Map();
//             a = [];
//             i = {};
//             for (var l = 0; l < o.length; l++) {
//                 var u = [];
//                 if (0 == l) {
//                     for (var c in o[l]) a.push(c);
//                 }
//                 var d = !0;
//                 for (var c in o[l])
//                     if (0 == c.length || o[l][c].indexOf("##1") >= 0 || o[l][c].indexOf("##2") >= 0) {
//                         d = !1;
//                         break;
//                     }
//                 if (d) {
//                     var p = 0;
//                     var h = void 0;
//                     for (var c in o[l]) 0 == p && (h = o[l][c]), u.push(o[l][c]), p++;
//                     if (h && h.length > 0) {
//                         i[h] = u;
//                     }
//                 }
//             }
//             for (var c in i) (s = new n()), e.jsonToValue(i[c], a, t, s), (h = parseInt(c)) && r.set(h, s);
//             return r;
//         }
//     };
//     e.excelToArray = function (e, t) {
//         t = t || ",";
//         var o = new RegExp("(\\" + t + '|\\r?\\n|\\r|^)(?:"([^"]*(?:""[^"]*)*)"|([^"\\' + t + "\\r\\n]*))", "gi");
//         var n = [[]];
//         for (var i = null; (i = o.exec(e)); ) {
//             var a;
//             var r = i[1];
//             if (r.length && r != t) {
//                 n.push([]);
//             }
//             if (i[2]) {
//                 a = i[2].replace(new RegExp('""', "g"), '"');
//             } else {
//                 a = i[3];
//             }
//             n[n.length - 1].push(a);
//         }
//         n.splice(-1);
//         return n;
//     };
//     e.excelToObject = function (t) {
//         var o = e.excelToArray(t);
//         var n = [];
//         for (var i = 1; i < o.length; i++) {
//             n[i - 1] = {};
//             for (var a = 0; a < o[0].length && a < o[i].length; a++) {
//                 var r = o[0][a];
//                 n[i - 1][r] = o[i][a];
//             }
//         }
//         return n;
//     };
//     e.excelToJson = function (t) {
//         return JSON.stringify(e.excelToObject(t));
//     };
//     e.getSameData = function (e, t, o, n, i) {
//         var a = [];
//         e.forEach(function (e) {
//             if (e[t] && e[t] == o) {
//                 n ? e[n] == i && a.push(e) : a.push(e);
//             }
//         });
//         return a;
//     };
//     return e;
// })();
// exports.ExcelUtil = i;

// import { BaseExcel, itemData } from './BaseExcel';

// export class ExcelUtil {
//     /**
//      * 将值转换为字符串
//      * @param type 值的类型
//      * @param value 值
//      * @returns 转换后的字符串
//      * 建议方法名: convertValueToString
//      */
//     static valueToString(type: string, value: any): string {
//         switch (type) {
//             case 'string':
//                 return value;
//             case 'string[]':
//                 return value.join(',');
//             case 'number':
//                 return value + '';
//             case 'number[]':
//                 return value.join(',');
//             case 'number[][]':
//                 return value.map((arr: number[]) => arr.join(',')).join(';');
//             case 'cc.Vec2':
//                 return `${value.x},${value.y}`;
//             case 'cc.Vec2[]':
//                 return value.map((vec: cc.Vec2) => `${vec.x},${vec.y}`).join(';');
//             case 'cc.Color':
//                 return value.toHEX('#rrggbb');
//             case 'cc.Color[]':
//                 return value.map((color: cc.Color) => color.toHEX('#rrggbb')).join(',');
//             case 'itemData':
//                 return this.itemToStr([value]);
//             case 'itemData[]':
//                 return value.map((item: any) => this.itemToStr([item])).join(';');
//             case 'boolean':
//                 return (value ? 1 : 0) + '';
//             case 'boolean[]':
//                 return value.map((bool: boolean) => (bool ? 1 : 0)).join(',');
//             default:
//                 return value;
//         }
//     }

//     /**
//      * 将字符串转换为指定类型的数据
//      * @param str 字符串
//      * @param type 目标类型
//      * @returns 转换后的数据
//      * 建议方法名: convertStringToDataType
//      */
//     static dataTypeConvert(str: string, type: string): any {
//         switch (type) {
//             case 'string':
//                 return str;
//             case 'string[]':
//                 return str.split(',');
//             case 'number':
//                 return str === '' ? 0 : Number(str);
//             case 'number[]':
//                 return this.stringToNumberArr(str);
//             case 'number[][]':
//                 return this.stringToNumberArrArr(str);
//             case 'cc.Vec2':
//                 return this.stringToVec(str);
//             case 'cc.Vec2[]':
//                 return this.stringToVecArr(str);
//             case 'cc.Color':
//                 return this.stringToColor(str);
//             case 'cc.Color[]':
//                 return this.stringToColorArr(str);
//             case 'itemData':
//                 return this.stringToItem(str);
//             case 'itemData[]':
//                 return this.stringToItemArr(str);
//             case 'boolean':
//                 return this.stringToBoolean(str);
//             case 'boolean[]':
//                 return this.stringToBooleanArr(str);
//             default:
//                 return str;
//         }
//     }

//     /**
//      * 将 itemData 数组转换为字符串
//      * @param items itemData 数组
//      * @returns 转换后的字符串
//      * 建议方法名: convertItemDataArrayToString
//      */
//     static itemToStr(items: any[]): string {
//         return items.map((item, index) => index === 0 ? `${item.key},${item.value}` : `;${item.key},${item.value}`).join('');
//     }

//     /**
//      * 将字符串转换为布尔值
//      * @param str 字符串
//      * @returns 布尔值
//      * 建议方法名: convertStringToBoolean
//      */
//     static stringToBoolean(str: string): boolean {
//         return !(str === '' || str === '0' || str.toLowerCase() === 'false');
//     }

//     /**
//      * 将字符串转换为布尔值数组
//      * @param str 字符串
//      * @returns 布尔值数组
//      * 建议方法名: convertStringToBooleanArray
//      */
//     static stringToBooleanArr(str: string): boolean[] {
//         return str.length > 0 ? str.split(',').map(this.stringToBoolean) : [];
//     }

//     /**
//      * 将字符串转换为颜色数组
//      * @param str 字符串
//      * @returns 颜色数组
//      * 建议方法名: convertStringToColorArray
//      */
//     static stringToColorArr(str: string): cc.Color[] {
//         return str.length > 0 ? str.split(',').map(this.stringToColor) : [];
//     }

//     /**
//      * 将字符串转换为颜色
//      * @param str 字符串
//      * @returns 颜色
//      * 建议方法名: convertStringToColor
//      */
//     static stringToColor(str: string): cc.Color {
//         if (str.length >= 6) {
//             const r = parseInt(str.substring(0, 2), 16);
//             const g = parseInt(str.substring(2, 4), 16);
//             const b = parseInt(str.substring(4, 6), 16);
//             const a = str.length > 6 ? parseInt(str.substring(6, 8), 16) : 255;
//             return new cc.Color(r, g, b, a);
//         }
//         return cc.Color.BLACK;
//     }

//     /**
//      * 将字符串转换为 Vec2 数组
//      * @param str 字符串
//      * @returns Vec2 数组
//      * 建议方法名: convertStringToVec2Array
//      */
//     static stringToVecArr(str: string): cc.Vec2[] {
//         return str.length > 0 ? str.split(';').map(this.stringToVec) : [];
//     }

//     /**
//      * 将字符串转换为 Vec2
//      * @param str 字符串
//      * @returns Vec2
//      * 建议方法名: convertStringToVec2
//      */
//     static stringToVec(str: string): cc.Vec2 {
//         const arr = this.stringToNumberArr(str);
//         return arr.length >= 2 ? new cc.Vec2(arr[0], arr[1]) : new cc.Vec2(0, 0);
//     }

//     /**
//      * 将字符串转换为数字数组
//      * @param str 字符串
//      * @returns 数字数组
//      * 建议方法名: convertStringToNumberArray
//      */
//     static stringToNumberArr(str: string): number[] {
//         return str.length > 0 ? str.split(',').map(Number) : [];
//     }

//     /**
//      * 将字符串转换为二维数字数组
//      * @param str 字符串
//      * @returns 二维数字数组
//      * 建议方法名: convertStringToNumber2DArray
//      */
//     static stringToNumberArrArr(str: string): number[][] {
//         return str.length > 0 ? str.split(';').map(this.stringToNumberArr) : [];
//     }

//     /**
//      * 将 itemData 转换为字符串
//      * @param item itemData
//      * @returns 转换后的字符串
//      * 建议方法名: convertItemDataToString
//      */
//     static itemToString(item: any): string {
//         return item.extent ? `${item.key},${item.extent},${item.value}` : `${item.key},${item.value}`;
//     }

//     /**
//      * 将字符串转换为 itemData
//      * @param str 字符串
//      * @returns itemData
//      * 建议方法名: convertStringToItemData
//      */
//     static stringToItem(str: string): any {
//         const arr = this.stringToNumberArr(str);
//         const length = arr.length;
//         if (length === 2) {
//             return new itemData(arr[0], arr[1]);
//         } else if (length > 2) {
//             return new itemData(arr[0], arr[1], arr[2]);
//         }
//         return null;
//     }

//     /**
//      * 将字符串转换为 itemData 数组
//      * @param str 字符串
//      * @returns itemData 数组
//      * 建议方法名: convertStringToItemDataArray
//      */
//     static stringToItemArr(str: string): any[] {
//         return str.length > 0 ? str.split(';').map(this.stringToItem) : [];
//     }

//     /**
//      * 将 itemData 数组转换为字符串
//      * @param items itemData 数组
//      * @returns 转换后的字符串
//      * 建议方法名: convertItemDataArrayToString
//      */
//     static itemArrToString(items: any[]): string {
//         return items.map(this.itemToString).join(';');
//     }

//     /**
//      * 将 JSON 数据转换为值
//      * @param data JSON 数据
//      * @param header 表头
//      * @param typeStr 类型字符串
//      * @param target 目标对象
//      * 建议方法名: convertJsonToValue
//      */
//     static jsonToValue(data: any, header: any, typeStr: any, target: any): void {
//         const specialType = { talk_task: 'talk' }[typeStr];
//         for (const key in header) {
//             const value = data[key] || '';
//             if (specialType && header[key] === specialType && value.indexOf('\\n') >= 0) {
//                 value.replace(/\\n/g, '\n');
//             }
//             target[header[key]] = this.dataTypeConvert(value, target.typeStr[header[key]]);
//         }
//     }

//     /**
//      * 转换 Excel 数据
//      * @param t 类型
//      * @param o 数据
//      * @param n 构造函数
//      * @returns 转换后的数据
//      * 建议方法名: convertExcelData
//      */
//     static convert(t: string, o: any, n: any): Map<number, any> {
//         if (o instanceof cc.JsonAsset) {
//                     var i = o.json.rows;
//                     var a = o.json.header;
//                     var r = new Map();
//                     for (var c in i) {
//                         var s = new n();
//                         this.jsonToValue(i[c], a, t, s);
//                         if ((h = parseInt(c))) {
//                             r.set(h, s);
//                         }
//                     }
//                     return r;
//                 }
//                 if (o instanceof Array) {
//                     r = new Map();
//                     a = [];
//                     i = {};
//                     for (var l = 0; l < o.length; l++) {
//                         var u = [];
//                         if (0 == l) {
//                             for (var c in o[l]) a.push(c);
//                         }
//                         var d = !0;
//                         for (var c in o[l])
//                             if (0 == c.length || o[l][c].indexOf("##1") >= 0 || o[l][c].indexOf("##2") >= 0) {
//                                 d = !1;
//                                 break;
//                             }
//                         if (d) {
//                             var p = 0;
//                             var h = void 0;
//                             for (var c in o[l]) 0 == p && (h = o[l][c]), u.push(o[l][c]), p++;
//                             if (h && h.length > 0) {
//                                 i[h] = u;
//                             }
//                         }
//                     }
//                     for (var c in i) (s = new n()), this.jsonToValue(i[c], a, t, s), (h = parseInt(c)) && r.set(h, s);
//                     return r;
//                 }
//         // let result = new Map < number, any> ();
//         // if (data instanceof cc.JsonAsset) {
//         //     const rows = data.json.rows;
//         //     const header = data.json.header;
//         //     for (const key in rows) {
//         //         const instance = new constructor();
//         //         this.jsonToValue(rows[key], header, type, instance);
//         //         const id = parseInt(key);
//         //         if (id) {
//         //             result.set(id, instance);
//         //         }
//         //     }
//         // } else if (Array.isArray(data)) {
//         //     const header: string[] = [];
//         //     const tempData: any = {};
//         //     for (let i = 0; i < data.length; i++) {
//         //         const row = data[i];
//         //         if (i === 0) {
//         //             for (const key in row) {
//         //                 header.push(key);
//         //             }
//         //         }
//         //         let isValid = true;
//         //         for (const key in row) {
//         //             if (key.length === 0 || row[key].indexOf('##1') >= 0 || row[key].indexOf('##2') >= 0) {
//         //                 isValid = false;
//         //                 break;
//         //             }
//         //         }
//         //         if (isValid) {
//         //             const id = row[header[0]];
//         //             if (id && id.length > 0) {
//         //                 tempData[id] = row;
//         //             }
//         //         }
//         //     }
//         //     for (const key in tempData) {
//         //         const instance = new constructor();
//         //         this.jsonToValue(tempData[key], header, type, instance);
//         //         const id = parseInt(key);
//         //         if (id) {
//         //             result.set(id, instance);
//         //         }
//         //     }
//         // }
//         // return result;
//     }

//     /**
//      * 将 Excel 数据转换为数组
//      * @param str Excel 数据字符串
//      * @param delimiter 分隔符
//      * @returns 转换后的数组
//      * 建议方法名: convertExcelToArray
//      */
//     static excelToArray(str: string, delimiter: string = ','): any[][] {
//         const regex = new RegExp(`(\\${delimiter}|\\r?\\n|\\r|^)(?:"([^"]*(?:""[^"]*)*)"|([^"\\${delimiter}\\r\\n]*))`, 'gi');
//         const result: any[][] = [[]];
//         let match: RegExpExecArray | null;
//         while ((match = regex.exec(str))) {
//             const matchedDelimiter = match[1];
//             if (matchedDelimiter.length && matchedDelimiter !== delimiter) {
//                 result.push([]);
//             }
//             const matchedValue = match[2] ? match[2].replace(/""/g, '"') : match[3];
//             result[result.length - 1].push(matchedValue);
//         }
//         result.splice(-1);
//         return result;
//     }

//     /**
//      * 将 Excel 数据转换为对象数组
//      * @param str Excel 数据字符串
//      * @returns 对象数组
//      * 建议方法名: convertExcelToObjectArray
//      */
//     static excelToObject(str: string): any[] {
//         const arrayData = this.excelToArray(str);
//         const result: any[] = [];
//         for (let i = 1; i < arrayData.length; i++) {
//             const obj: any = {};
//             for (let j = 0; j < arrayData[0].length && j < arrayData[i].length; j++) {
//                 const key = arrayData[0][j];
//                 obj[key] = arrayData[i][j];
//             }
//             result.push(obj);
//         }
//         return result;
//     }

//     /**
//      * 将 Excel 数据转换为 JSON 字符串
//      * @param str Excel 数据字符串
//      * @returns JSON 字符串
//      * 建议方法名: convertExcelToJson
//      */
//     static excelToJson(str: string): string {
//         return JSON.stringify(this.excelToObject(str));
//     }

//     /**
//      * 获取相同数据
//      * @param data 数据数组
//      * @param key 键
//      * @param value 值
//      * @param compareKey 比较键
//      * @param compareValue 比较值
//      * @returns 相同数据数组
//      * 建议方法名: getMatchingData
//      */
//     static getSameData(e, t, o, n?, i?) {
//         var a = [];
//         e.forEach(function (e) {
//             if (e[t] && e[t] == o) {
//                 n ? e[n] == i && a.push(e) : a.push(e);
//             }
//         });
//         return a;
//     };
// }


import { itemData } from './BaseExcel';

/**
 * 建议类名：ExcelUtility
 */
export class ExcelUtil {
    /**
     * 建议方法名: convertValueToString
     * 将值转换为字符串
     * @param type 值的类型
     * @param value 值
     * @returns 转换后的字符串
     */
    static convertValueToString(valueType: string, valueToConvert: any): string {
        switch (valueType) {
            case 'string':
                return valueToConvert;
            case 'string[]':
                return valueToConvert.join(',');
            case 'number':
                return valueToConvert + '';
            case 'number[]':
                return valueToConvert.join(',');
            case 'number[][]':
                return valueToConvert.map((numArray: number[]) => numArray.join(',')).join(';');
            case 'cc.Vec2':
                return `${valueToConvert.x},${valueToConvert.y}`;
            case 'cc.Vec2[]':
                return valueToConvert.map((vec: cc.Vec2) => `${vec.x},${vec.y}`).join(';');
            case 'cc.Color':
                return valueToConvert.toHEX('#rrggbb');
            case 'cc.Color[]':
                return valueToConvert.map((color: cc.Color) => color.toHEX('#rrggbb')).join(',');
            case 'itemData':
                return this.convertItemDataArrayToString([valueToConvert]);
            case 'itemData[]':
                return valueToConvert.map((item: any) => this.convertItemDataArrayToString([item])).join(';');
            case 'boolean':
                return (valueToConvert ? 1 : 0) + '';
            case 'boolean[]':
                return valueToConvert.map((bool: boolean) => (bool ? 1 : 0)).join(',');
            default:
                return valueToConvert;
        }
    }

    /**
     * 建议方法名: convertStringToDataType
     * 将字符串转换为指定类型的数据
     * @param str 字符串
     * @param type 目标类型
     * @returns 转换后的数据
     */
    static convertStringToDataType(stringValue: string, targetType: string): any {
        switch (targetType) {
            case 'string':
                return stringValue;
            case 'string[]':
                return stringValue.split(',');
            case 'number':
                return stringValue === '' ? 0 : Number(stringValue);
            case 'number[]':
                return this.convertStringToNumberArray(stringValue);
            case 'number[][]':
                return this.convertStringToNumber2DArray(stringValue);
            case 'cc.Vec2':
                return this.convertStringToVec2(stringValue);
            case 'cc.Vec2[]':
                return this.convertStringToVec2Array(stringValue);
            case 'cc.Color':
                return this.convertStringToColor(stringValue);
            case 'cc.Color[]':
                return this.convertStringToColorArray(stringValue);
            case 'itemData':
                return this.convertStringToItemData(stringValue);
            case 'itemData[]':
                return this.convertStringToItemDataArray(stringValue);
            case 'boolean':
                return this.convertStringToBoolean(stringValue);
            case 'boolean[]':
                return this.convertStringToBooleanArray(stringValue);
            default:
                return stringValue;
        }
    }

    /**
     * 建议方法名: convertItemDataArrayToString
     * 将 itemData 数组转换为字符串
     * @param items itemData 数组
     * @returns 转换后的字符串
     */
    static convertItemDataArrayToString(itemDataArray: any[]): string {
        return itemDataArray.map((item, index) => index === 0 ? `${item.key},${item.value}` : `;${item.key},${item.value}`).join('');
    }

    /**
     * 建议方法名: convertStringToBoolean
     * 将字符串转换为布尔值
     * @param str 字符串
     * @returns 布尔值
     */
    static convertStringToBoolean(booleanStr: string): boolean {
        return !(booleanStr === '' || booleanStr === '0' || booleanStr.toLowerCase() === 'false');
    }

    /**
     * 建议方法名: convertStringToBooleanArray
     * 将字符串转换为布尔值数组
     * @param str 字符串
     * @returns 布尔值数组
     */
    static convertStringToBooleanArray(booleanStrArray: string): boolean[] {
        return booleanStrArray.length > 0 ? booleanStrArray.split(',').map(this.convertStringToBoolean) : [];
    }

    /**
     * 建议方法名: convertStringToColorArray
     * 将字符串转换为颜色数组
     * @param str 字符串
     * @returns 颜色数组
     */
    static convertStringToColorArray(colorStrArray: string): cc.Color[] {
        return colorStrArray.length > 0 ? colorStrArray.split(',').map(this.convertStringToColor) : [];
    }

    /**
     * 建议方法名: convertStringToColor
     * 将字符串转换为颜色
     * @param str 字符串
     * @returns 颜色
     */
    static convertStringToColor(colorStr: string): cc.Color {
        if (colorStr.length >= 6) {
            const r = parseInt(colorStr.substring(0, 2), 16);
            const g = parseInt(colorStr.substring(2, 4), 16);
            const b = parseInt(colorStr.substring(4, 6), 16);
            const a = colorStr.length > 6 ? parseInt(colorStr.substring(6, 8), 16) : 255;
            return new cc.Color(r, g, b, a);
        }
        return cc.Color.BLACK;
    }

    /**
     * 建议方法名: convertStringToVec2Array
     * 将字符串转换为 Vec2 数组
     * @param str 字符串
     * @returns Vec2 数组
     */
    static convertStringToVec2Array(vec2StrArray: string): cc.Vec2[] {
        return vec2StrArray.length > 0 ? vec2StrArray.split(';').map(this.convertStringToVec2) : [];
    }

    /**
     * 建议方法名: convertStringToVec2
     * 将字符串转换为 Vec2
     * @param str 字符串
     * @returns Vec2
     */
    static convertStringToVec2(vec2Str: string): cc.Vec2 {
        const numArray = this.convertStringToNumberArray(vec2Str);
        return numArray.length >= 2 ? new cc.Vec2(numArray[0], numArray[1]) : new cc.Vec2(0, 0);
    }

    /**
     * 建议方法名: convertStringToNumberArray
     * 将字符串转换为数字数组
     * @param str 字符串
     * @returns 数字数组
     */
    static convertStringToNumberArray(numberStr: string): number[] {
        return numberStr.length > 0 ? numberStr.split(',').map(Number) : [];
    }

    /**
     * 建议方法名: convertStringToNumber2DArray
     * 将字符串转换为二维数字数组
     * @param str 字符串
     * @returns 二维数字数组
     */
    static convertStringToNumber2DArray(number2DStr: string): number[][] {
        return number2DStr.length > 0 ? number2DStr.split(';').map(this.convertStringToNumberArray) : [];
    }

    /**
     * 建议方法名: convertItemDataToString
     * 将 itemData 转换为字符串
     * @param item itemData
     * @returns 转换后的字符串
     */
    static convertItemDataToString(item: any): string {
        return item.extent ? `${item.key},${item.extent},${item.value}` : `${item.key},${item.value}`;
    }

    /**
     * 建议方法名: convertStringToItemData
     * 将字符串转换为 itemData
     * @param str 字符串
     * @returns itemData
     */
    static convertStringToItemData(itemStr: string): any {
        const numArray = this.convertStringToNumberArray(itemStr);
        const length = numArray.length;
        if (length === 2) {
            return new itemData(numArray[0], numArray[1]);
        } else if (length > 2) {
            return new itemData(numArray[0], numArray[1], numArray[2]);
        }
        return null;
    }

    /**
     * 建议方法名: convertStringToItemDataArray
     * 将字符串转换为 itemData 数组
     * @param str 字符串
     * @returns itemData 数组
     */
    static convertStringToItemDataArray(itemStrArray: string): any[] {
        return itemStrArray.length > 0 ? itemStrArray.split(';').map(this.convertStringToItemData) : [];
    }

    /**
     * 建议方法名: convertItemDataArrayToString
     * 将 itemData 数组转换为字符串
     * @param items itemData 数组
     * @returns 转换后的字符串
     */
    static convertItemArrayToString(itemDataArray: any[]): string {
        return itemDataArray.map(this.convertItemDataToString).join(';');
    }

    /**
     * 建议方法名: convertJsonToValue
     * 将 JSON 数据转换为值
     * @param data JSON 数据
     * @param header 表头
     * @param typeStr 类型字符串
     * @param target 目标对象
     */
    static convertJsonToValue(jsonData: any, jsonHeader: any, typeStr: any, targetObj: any): void {
        const specialType = { talk_task: 'talk' }[typeStr];
        for (const key in jsonHeader) {
            const value = jsonData[key] || '';
            if (specialType && jsonHeader[key] === specialType && value.indexOf('\\n') >= 0) {
                value.replace(/\\n/g, '\n');
            }
            targetObj[jsonHeader[key]] = this.convertStringToDataType(value, targetObj.typeStr[jsonHeader[key]]);
        }
    }

    /**
     * 建议方法名: convertExcelData
     * 转换 Excel 数据
     * @param t 类型
     * @param o 数据
     * @param n 构造函数
     * @returns 转换后的数据
     */
    static convertExcelData(type: string, dataObj: any, constructorFn: any): Map<number, any> {
        let resultMap = new Map<number, any>();

        if (dataObj instanceof cc.JsonAsset) {
            const rows = dataObj.json.rows;
            const headers = dataObj.json.header;

            for (const key in rows) {
                const instance = new constructorFn();
                this.convertJsonToValue(rows[key], headers, type, instance);
                const id = parseInt(key);
                if (id) {
                    resultMap.set(id, instance);
                }
            }
        } else if (Array.isArray(dataObj)) {
            const headers: string[] = [];
            const tempData: any = {};

            dataObj.forEach((row: any, index: number) => {
                if (index === 0) {
                    for (const key in row) {
                        headers.push(key);
                    }
                }

                let isValid = true;

                for (const key in row) {
                    if (key.length === 0 || row[key].indexOf('##1') >= 0 || row[key].indexOf('##2') >= 0) {
                        isValid = false;
                        break;
                    }
                }

                if (isValid) {
                    const id = row[headers[0]];
                    if (id && id.length > 0) {
                        tempData[id] = row;
                    }
                }
            });

            for (const key in tempData) {
                const instance = new constructorFn();
                this.convertJsonToValue(tempData[key], headers, type, instance);
                const id = parseInt(key);
                if (id) {
                    resultMap.set(id, instance);
                }
            }
        }
        
        return resultMap;
    }

    /**
     * 建议方法名: convertExcelToArray
     * 将 Excel 数据转换为数组
     * @param str Excel 数据字符串
     * @param delimiter 分隔符
     * @returns 转换后的数组
     */
    static convertExcelToArray(excelStr: string, delimiter: string = ','): any[][] {
        const regex = new RegExp(`(\\${delimiter}|\\r?\\n|\\r|^)(?:"([^"]*(?:""[^"]*)*)"|([^"\\${delimiter}\\r\\n]*))`, 'gi');
        const resultArray: any[][] = [[]];
        let match: RegExpExecArray | null;
        while ((match = regex.exec(excelStr))) {
            const matchedDelimiter = match[1];
            if (matchedDelimiter.length && matchedDelimiter !== delimiter) {
                resultArray.push([]);
            }
            const matchedValue = match[2] ? match[2].replace(/""/g, '"') : match[3];
            resultArray[resultArray.length - 1].push(matchedValue);
        }
        resultArray.splice(-1);
        return resultArray;
    }

    /**
     * 建议方法名: convertExcelToObjectArray
     * 将 Excel 数据转换为对象数组
     * @param str Excel 数据字符串
     * @returns 对象数组
     */
    static convertExcelToObjectArray(excelStr: string): any[] {
        const arrayData = this.convertExcelToArray(excelStr);
        const resultArray: any[] = [];
        for (let i = 1; i < arrayData.length; i++) {
            const obj: any = {};
            for (let j = 0; j < arrayData[0].length && j < arrayData[i].length; j++) {
                const key = arrayData[0][j];
                obj[key] = arrayData[i][j];
            }
            resultArray.push(obj);
        }
        return resultArray;
    }

    /**
     * 建议方法名: convertExcelToJson
     * 将 Excel 数据转换为 JSON 字符串
     * @param str Excel 数据字符串
     * @returns JSON 字符串
     */
    static convertExcelToJson(excelStr: string): string {
        return JSON.stringify(this.convertExcelToObjectArray(excelStr));
    }

    /**
     * 建议方法名: getMatchingData
     * 获取相同数据
     * @param data 数据数组
     * @param key 键
     * @param value 值
     * @param compareKey 比较键
     * @param compareValue 比较值
     * @returns 相同数据数组
     */
    static getMatchingData(dataArray: any[], key: string, value: any, compareKey?: string, compareValue?: any): any[] {
        const resultArray: any[] = [];
        dataArray.forEach((dataItem) => {
            if (dataItem[key] && dataItem[key] === value) {
                if (compareKey) {
                    if (dataItem[compareKey] === compareValue) {
                        resultArray.push(dataItem);
                    }
                } else {
                    resultArray.push(dataItem);
                }
            }
        });
        return resultArray;
    }
}